home *** CD-ROM | disk | FTP | other *** search
/ Clickx 115 / Clickx 115.iso / software / tools / windows / tails-i386-0.16.iso / live / filesystem.squashfs / usr / bin / smime_keys < prev    next >
Encoding:
Text File  |  2011-12-19  |  26.6 KB  |  1,014 lines
  1. #! /usr/bin/perl -w
  2.  
  3. # Copyright (C) 2001,2002 Oliver Ehli <elmy@acm.org>
  4. # Copyright (C) 2001 Mike Schiraldi <raldi@research.netsol.com>
  5. # Copyright (C) 2003 Bjoern Jacke <bjoern@j3e.de>
  6. #
  7. #     This program is free software; you can redistribute it and/or modify
  8. #     it under the terms of the GNU General Public License as published by
  9. #     the Free Software Foundation; either version 2 of the License, or
  10. #     (at your option) any later version.
  11. # 
  12. #     This program is distributed in the hope that it will be useful,
  13. #     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. #     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. #     GNU General Public License for more details.
  16. # 
  17. #     You should have received a copy of the GNU General Public License
  18. #     along with this program; if not, write to the Free Software
  19. #     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20.  
  21. use strict;
  22. use File::Copy;
  23. use File::Glob ':glob';
  24.  
  25. umask 077;
  26.  
  27. require "timelocal.pl";
  28.  
  29. sub usage ();
  30. sub newfile ($;$$);
  31. sub mutt_Q ($ );
  32. sub mycopy ($$);
  33.  
  34. #  directory setup routines
  35. sub mkdir_recursive ($ );
  36. sub init_paths ();
  37.  
  38. # key/certificate management methods
  39. sub list_certs ();
  40. sub query_label ();
  41. sub add_entry ($$$$$ );
  42. sub add_certificate ($$$$;$ );
  43. sub add_key ($$$$);
  44. sub add_root_cert ($ );
  45. sub parse_pem (@ );
  46. sub handle_pem (@ );
  47. sub modify_entry ($$$;$ );
  48. sub remove_pair ($ );
  49. sub change_label ($ );
  50. sub verify_cert($$);
  51. sub do_verify($$$ );
  52.               
  53. # Get the directories mutt uses for certificate/key storage.
  54.  
  55. my $mutt = $ENV{MUTT_CMDLINE} || 'mutt';
  56. my $opensslbin = "/usr/bin/openssl";
  57. my @tempfiles = ();
  58. my @cert_tmp_file = ();
  59.  
  60. my $tmpdir;
  61. my $private_keys_path = mutt_Q 'smime_keys';
  62. die "smime_keys is not set in mutt's configuration file"
  63.     if length $private_keys_path == 0;
  64.  
  65. my $certificates_path = mutt_Q 'smime_certificates';
  66. die "smime_certificates is not set in mutt's configuration file"
  67.     if length $certificates_path == 0;
  68. my $root_certs_path   = mutt_Q 'smime_ca_location';
  69. die "smime_ca_location is not set in mutt's configuration file"
  70.     if length $root_certs_path == 0;
  71.  
  72. my $root_certs_switch;
  73. if ( -d $root_certs_path) {
  74.     $root_certs_switch = -CApath;
  75. } else {
  76.     $root_certs_switch = -CAfile;
  77. }
  78.  
  79.  
  80. #
  81. # OPS
  82. #
  83.  
  84.  
  85. sub get_certs {
  86.     my $file = shift;
  87.     return undef unless (defined($file) && -e $file);
  88.  
  89.     open IN, "<$file";
  90.  
  91.     my @certs = ();
  92.     my $in_cert = 0;
  93.     my $cert = q{};
  94.     while ( <IN> ) {
  95.         $in_cert = 1 if ( /^-----BEGIN CERTIFICATE-----$/ );
  96.         $cert .= $_;
  97.  
  98.         if ( /^-----END CERTIFICATE-----$/ )  {
  99.             push @certs, $cert;
  100.             $cert = q{};
  101.             $in_cert = 0;
  102.         }
  103.     }
  104.  
  105.     return @certs;
  106. }
  107.  
  108. if(@ARGV == 1 and $ARGV[0] eq "init") {
  109.     init_paths;
  110. }
  111. elsif(@ARGV == 1 and $ARGV[0] eq "list") {
  112.     list_certs;
  113. }
  114. elsif(@ARGV == 2 and $ARGV[0] eq "label") {
  115.     change_label($ARGV[1]);
  116. }
  117. elsif(@ARGV == 2 and $ARGV[0] eq "add_cert") {
  118.     foreach my $cert ( get_certs( $ARGV[1] ) ) {
  119.  
  120.         my $file = sprintf( '/tmp/smime-%d.%d', $$, int(rand( 999999 ) ) );
  121.         print STDERR "TMPFILE: $file\n";
  122.         if ( -e $file ) {
  123.             die( "ERROR: TMPFILE $file existss?!?!" );
  124.         }
  125.         open OUT, ">$file";
  126.         print OUT $cert;
  127.         close OUT;
  128.  
  129.         my $format = -B $file ? 'DER' : 'PEM'; 
  130.         my $cmd = "$opensslbin x509 -noout -hash -in $file -inform $format";
  131.  
  132.         my $cert_hash = `$cmd`;
  133.         $? and die "'$cmd' returned $?";
  134.         chomp($cert_hash); 
  135.         my $label = query_label;
  136.         &add_certificate($ARGV[1], \$cert_hash, 1, $label, '?');
  137.         unlink $file;
  138.     }
  139. }
  140. elsif(@ARGV == 2 and $ARGV[0] eq "add_pem") {
  141.     -e $ARGV[1] and -s $ARGV[1] or die("$ARGV[1] is nonexistent or empty.");
  142.     open(PEM_FILE, "<$ARGV[1]") or die("Can't open $ARGV[1]: $!");
  143.     my @pem = <PEM_FILE>;
  144.     close(PEM_FILE);
  145.     handle_pem(@pem);
  146. }
  147. elsif( @ARGV == 2 and $ARGV[0] eq "add_p12") {
  148.     -e $ARGV[1] and -s $ARGV[1] or die("$ARGV[1] is nonexistent or empty.");
  149.  
  150.     print "\nNOTE: This will ask you for two passphrases:\n";
  151.     print "       1. The passphrase you used for exporting\n";
  152.     print "       2. The passphrase you wish to secure your private key with.\n\n";
  153.  
  154.     my $pem_file = "$ARGV[1].pem";
  155.     
  156.     my $cmd = "$opensslbin pkcs12 -in $ARGV[1] -out $pem_file";
  157.     system $cmd and die "'$cmd' returned $?";
  158.     
  159.     -e $pem_file and -s $pem_file or die("Conversion of $ARGV[1] failed.");
  160.     open(PEM_FILE, $pem_file) or die("Can't open $pem_file: $!");
  161.     my @pem = <PEM_FILE>;
  162.     close(PEM_FILE);
  163.     unlink $pem_file;
  164.     handle_pem(@pem);
  165. }
  166. elsif(@ARGV == 4 and $ARGV[0] eq "add_chain") {
  167.     my $mailbox;
  168.     my $format = -B $ARGV[2] ? 'DER' : 'PEM'; 
  169.     my $cmd = "$opensslbin x509 -noout -hash -in $ARGV[2] -inform $format";
  170.     my $cert_hash = `$cmd`;
  171.  
  172.     $? and die "'$cmd' returned $?";
  173.  
  174.     $format = -B $ARGV[3] ? 'DER' : 'PEM'; 
  175.  
  176.     $cmd = "$opensslbin x509 -noout -hash -in $ARGV[3] -inform $format";
  177.     my $issuer_hash = `$cmd`;
  178.     $? and die "'$cmd' returned $?";
  179.     
  180.     chomp($cert_hash); 
  181.     chomp($issuer_hash);
  182.  
  183.     my $label = query_label;
  184.     
  185.     add_certificate($ARGV[3], \$issuer_hash, 0, $label); 
  186.     my @mailbox = &add_certificate($ARGV[2], \$cert_hash, 1, $label, $issuer_hash);
  187.     
  188.     foreach $mailbox (@mailbox) {
  189.       chomp($mailbox);
  190.       add_key($ARGV[1], $cert_hash, $mailbox, $label);
  191.     }
  192. }
  193. elsif((@ARGV == 2 or @ARGV == 3) and $ARGV[0] eq "verify") {
  194.     verify_cert($ARGV[1], $ARGV[2]);
  195. }
  196. elsif(@ARGV == 2 and $ARGV[0] eq "remove") {
  197.     remove_pair($ARGV[1]);
  198. }
  199. elsif(@ARGV == 2 and $ARGV[0] eq "add_root") {
  200.     add_root_cert($ARGV[1]);
  201. }
  202. else {    
  203.     usage;
  204.     exit(1);
  205. }
  206.  
  207. exit(0);
  208.  
  209.  
  210.  
  211.  
  212.  
  213. ##############  sub-routines  ########################
  214.  
  215. sub usage () {
  216.     print <<EOF;
  217.  
  218. Usage: smime_keys <operation>  [file(s) | keyID [file(s)]]
  219.  
  220.         with operation being one of:
  221.  
  222.         init      : no files needed, inits directory structure.
  223.  
  224.         list      : lists the certificates stored in database.
  225.         label     : keyID required. changes/removes/adds label.
  226.         remove    : keyID required.
  227.         verify    : 1=keyID and optionally 2=CRL
  228.                     Verifies the certificate chain, and optionally wether
  229.                     this certificate is included in supplied CRL (PEM format).
  230.                     Note: to verify all certificates at the same time,
  231.                     replace keyID with "all"
  232.  
  233.         add_cert  : certificate required.
  234.         add_chain : three files reqd: 1=Key, 2=certificate
  235.                     plus 3=intermediate certificate(s).
  236.         add_p12   : one file reqd. Adds keypair to database.
  237.                     file is PKCS12 (e.g. export from netscape).
  238.         add_pem   : one file reqd. Adds keypair to database.
  239.                     (file was converted from e.g. PKCS12).
  240.  
  241.         add_root  : one file reqd. Adds PEM root certificate to the location
  242.                     specified within muttrc (smime_verify_* command)
  243.  
  244. EOF
  245. }
  246.  
  247. sub mutt_Q ($) {
  248.     my $var = shift or die;
  249.  
  250.     my $cmd = "$mutt -v >/dev/null 2>/dev/null";
  251.     system ($cmd) == 0 
  252.         or die<<EOF;
  253. Couldn't launch mutt. I attempted to do so by running the command "$mutt".
  254. If that's not the right command, you can override it by setting the 
  255. environment variable \$MUTT_CMDLINE
  256. EOF
  257.  
  258.     $cmd = "$mutt -Q $var 2>/dev/null";
  259.     my $answer = `$cmd`;
  260.  
  261.     $? and die<<EOF;
  262. Couldn't look up the value of the mutt variable "$var". 
  263. You must set this in your mutt config file. See contrib/smime.rc for an example.
  264. EOF
  265. #'
  266.  
  267.     $answer =~ /\"(.*?)\"/ and return bsd_glob($1, GLOB_TILDE | GLOB_NOCHECK);
  268.     
  269.     $answer =~ /^Mutt (.*?) / and die<<EOF;
  270. This script requires mutt 1.5.0 or later. You are using mutt $1.
  271. EOF
  272.     
  273.     die "Value of $var is weird\n";
  274. }
  275.  
  276. sub mycopy ($$) {
  277.     my $source = shift or die;
  278.     my $dest = shift or die;
  279.  
  280.     copy $source, $dest or die "Problem copying $source to $dest: $!\n";
  281. }
  282.  
  283. #
  284. #  directory setup routines
  285. #
  286.  
  287.  
  288. sub mkdir_recursive ($) {
  289.     my $path = shift or die;
  290.     my $tmp_path;
  291.     
  292.     for my $dir (split /\//, $path) {
  293.         $tmp_path .= "$dir/";
  294.  
  295.         -d $tmp_path 
  296.             or mkdir $tmp_path, 0700
  297.                 or die "Can't mkdir $tmp_path: $!";
  298.     }
  299. }
  300.  
  301. sub init_paths () {
  302.     mkdir_recursive($certificates_path);
  303.     mkdir_recursive($private_keys_path);
  304.  
  305.     my $file;
  306.  
  307.     $file = $certificates_path . "/.index";
  308.     -f $file or open(TMP_FILE, ">$file") and close(TMP_FILE)
  309.         or die "Can't touch $file: $!";
  310.  
  311.     $file = $private_keys_path . "/.index";
  312.     -f $file or open(TMP_FILE, ">$file") and close(TMP_FILE)
  313.         or die "Can't touch $file: $!";
  314. }
  315.  
  316.  
  317.  
  318. #
  319. # certificate management methods
  320. #
  321.  
  322. sub list_certs () {
  323.   my %keyflags = ( 'i', '(Invalid)',  'r', '(Revoked)', 'e', '(Expired)',
  324.            'u', '(Unverified)', 'v', '(Valid)', 't', '(Trusted)');
  325.  
  326.   open(INDEX, "<$certificates_path/.index") or 
  327.     die "Couldn't open $certificates_path/.index: $!";
  328.   
  329.   print "\n";
  330.   while(<INDEX>) {
  331.     my $tmp;
  332.     my @tmp;
  333.     my $tab = "            ";
  334.     my @fields = split;
  335.  
  336.     if($fields[2] eq '-') {
  337.       print "$fields[1]: Issued for: $fields[0] $keyflags{$fields[4]}\n";
  338.     } else {
  339.       print "$fields[1]: Issued for: $fields[0] \"$fields[2]\" $keyflags{$fields[4]}\n";
  340.     }
  341.  
  342.     my $certfile = "$certificates_path/$fields[1]";
  343.     my $cert;
  344.     {
  345.         open F, $certfile or
  346.             die "Couldn't open $certfile: $!";
  347.         local $/;
  348.         $cert = <F>;
  349.     close F;
  350.     }
  351.  
  352.     my $subject_in;
  353.     my $issuer_in;
  354.     my $date1_in;
  355.     my $date2_in;
  356.  
  357.     my $format = -B $certfile ? 'DER' : 'PEM'; 
  358.     my $cmd = "$opensslbin x509 -subject -issuer -dates -noout -in $certfile -inform $format";
  359.     ($subject_in, $issuer_in, $date1_in, $date2_in) = `$cmd`;
  360.     $? and print "ERROR: '$cmd' returned $?\n\n" and next;
  361.  
  362.  
  363.     my @subject = split(/\//, $subject_in);
  364.     while(@subject) {
  365.       $tmp = shift @subject;
  366.       ($tmp =~ /^CN\=/) and last;
  367.       undef $tmp;
  368.     }
  369.     defined $tmp and @tmp = split (/\=/, $tmp) and
  370.       print $tab."Subject: $tmp[1]\n";
  371.  
  372.     my @issuer = split(/\//, $issuer_in);
  373.     while(@issuer) {
  374.       $tmp = shift @issuer;
  375.       ($tmp =~ /^CN\=/) and last;
  376.       undef $tmp;
  377.     }
  378.     defined $tmp and @tmp = split (/\=/, $tmp) and
  379.       print $tab."Issued by: $tmp[1]";
  380.  
  381.     if ( defined $date1_in and defined $date2_in ) {
  382.       @tmp = split (/\=/, $date1_in);
  383.       $tmp = $tmp[1];
  384.       @tmp = split (/\=/, $date2_in);
  385.       print $tab."Certificate is not valid before $tmp".
  386.     $tab."                      or after  ".$tmp[1];
  387.     }
  388.  
  389.     -e "$private_keys_path/$fields[1]" and
  390.       print "$tab - Matching private key installed -\n";
  391.  
  392.     $format = -B "$certificates_path/$fields[1]" ? 'DER' : 'PEM'; 
  393.     $cmd = "$opensslbin x509 -purpose -noout -in $certfile -inform $format";
  394.     my $purpose_in = `$cmd`;
  395.     $? and die "'$cmd' returned $?";
  396.  
  397.     my @purpose = split (/\n/, $purpose_in);
  398.     print "$tab$purpose[0] (displays S/MIME options only)\n";
  399.     while(@purpose) {
  400.       $tmp = shift @purpose;
  401.       ($tmp =~ /^S\/MIME/ and $tmp =~ /Yes/) or next;
  402.       my @tmptmp = split (/:/, $tmp);
  403.       print "$tab  $tmptmp[0]\n";
  404.     }
  405.  
  406.     print "\n";
  407.   }
  408.   
  409.   close(INDEX);
  410. }
  411.  
  412.  
  413.  
  414. sub query_label () {
  415.     my @words;
  416.     my $input;
  417.  
  418.     print "\nYou may assign a label to this key, so you don't have to remember\n";
  419.     print "the key ID. This has to be _one_ word (no whitespaces).\n\n";
  420.  
  421.     print "Enter label: ";
  422.     $input = <STDIN>;
  423.     chomp($input) if ( defined($input) );
  424.  
  425.     my ($label, $junk) = split(/\s/, $input, 2) if ( defined($input) );
  426.     
  427.     defined $junk 
  428.         and print "\nUsing '$label' as label; ignoring '$junk'\n";
  429.  
  430.     defined $label || ($label =  "-");
  431.  
  432.     return $label;
  433. }
  434.  
  435.  
  436.  
  437. sub add_entry ($$$$$) {
  438.     my $mailbox = shift or die;
  439.     my $hashvalue = shift or die;
  440.     my $use_cert = shift;
  441.     my $label = shift or die;
  442.     my $issuer_hash = shift;
  443.  
  444.     my @fields;
  445.  
  446.     if ($use_cert) {
  447.         open(INDEX, "+<$certificates_path/.index") or 
  448.             die "Couldn't open $certificates_path/.index: $!";
  449.     }
  450.     else {
  451.         open(INDEX, "+<$private_keys_path/.index") or 
  452.             die "Couldn't open $private_keys_path/.index: $!";
  453.     }
  454.  
  455.     while(<INDEX>) {
  456.         @fields = split;
  457.         return if ($fields[0] eq $mailbox && $fields[1] eq $hashvalue);
  458.     }
  459.  
  460.     if ($use_cert) {
  461.         print INDEX "$mailbox $hashvalue $label $issuer_hash u\n";
  462.     }
  463.     else {
  464.         print INDEX "$mailbox $hashvalue $label \n";
  465.     }
  466.  
  467.     close(INDEX);
  468. }
  469.  
  470.  
  471. sub add_certificate ($$$$;$) {
  472.     my $filename = shift or die;
  473.     my $hashvalue = shift or die;
  474.     my $add_to_index = shift;
  475.     my $label = shift or die;
  476.     my $issuer_hash = shift;
  477.  
  478.     my $iter = 0;
  479.     my @mailbox;
  480.     my $mailbox;
  481.  
  482.     while(-e "$certificates_path/$$hashvalue.$iter") {
  483.         my ($t1, $t2);
  484.         my $format = -B $filename ? 'DER' : 'PEM'; 
  485.         my $cmd = "$opensslbin x509 -in $filename -inform $format -fingerprint -noout";
  486.         $t1 = `$cmd`;
  487.         $? and die "'$cmd' returned $?";
  488.  
  489.         $format = -B "$certificates_path/$$hashvalue.$iter" ? 'DER' : 'PEM'; 
  490.         $cmd = "$opensslbin x509 -in $certificates_path/$$hashvalue.$iter -inform $format -fingerprint -noout";
  491.         $t2 = `$cmd`;
  492.         $? and die "'$cmd' returned $?";
  493.         
  494.         $t1 eq $t2 and last;
  495.  
  496.         $iter++;
  497.     }
  498.     $$hashvalue .= ".$iter";
  499.     
  500.     if (-e "$certificates_path/$$hashvalue") {
  501.             print "\nCertificate: $certificates_path/$$hashvalue already installed.\n";
  502.     }
  503.     else {
  504.         mycopy $filename, "$certificates_path/$$hashvalue";
  505.  
  506.         if ($add_to_index) {
  507.             my $format = -B $filename ? 'DER' : 'PEM'; 
  508.         my $cmd = "$opensslbin x509 -in $filename -inform $format -email -noout";
  509.         @mailbox = `$cmd`;
  510.         $? and die "'$cmd' returned $?";
  511.  
  512.         foreach $mailbox (@mailbox) {
  513.           chomp($mailbox);
  514.           add_entry($mailbox, $$hashvalue, 1, $label, $issuer_hash);
  515.  
  516.           print "\ncertificate $$hashvalue ($label) for $mailbox added.\n";
  517.         }
  518.         verify_cert($$hashvalue, undef);
  519.         }
  520.         else {
  521.             print "added certificate: $certificates_path/$$hashvalue.\n";
  522.         }
  523.     }
  524.  
  525.     return @mailbox;
  526. }
  527.  
  528.  
  529. sub add_key ($$$$) {
  530.     my $file = shift or die;
  531.     my $hashvalue = shift or die;
  532.     my $mailbox = shift or die;
  533.     my $label = shift or die;
  534.  
  535.     unless (-e "$private_keys_path/$hashvalue") {
  536.         mycopy $file, "$private_keys_path/$hashvalue";
  537.     }    
  538.  
  539.     add_entry($mailbox, $hashvalue, 0, $label, "");
  540.     print "added private key: " .
  541.       "$private_keys_path/$hashvalue for $mailbox\n";
  542. } 
  543.  
  544.  
  545.  
  546.  
  547.  
  548.  
  549. sub parse_pem (@) {
  550.     my $state = 0;
  551.     my $cert_iter = 0;
  552.     my @bag_attribs;
  553.     my $numBags = 0;
  554.  
  555.     $cert_tmp_file[$cert_iter] = newfile("cert_tmp.$cert_iter","temp");
  556.     my $cert_tmp_iter = $cert_tmp_file[$cert_iter];
  557.     open(CERT_FILE, ">$cert_tmp_iter") 
  558.         or die "Couldn't open $cert_tmp_iter: $!";
  559.  
  560.     while($_ = shift(@_)) {
  561.         if(/^Bag Attributes/) {
  562.             $numBags++;
  563.             $state == 0 or  die("PEM-parse error at: $.");
  564.         $state = 1;
  565.             $bag_attribs[$cert_iter*4+1] = "";
  566.             $bag_attribs[$cert_iter*4+2] = "";
  567.             $bag_attribs[$cert_iter*4+3] = "";
  568.         }
  569.  
  570.         ($state == 1) and /localKeyID:\s*(.*)/ 
  571.             and ($bag_attribs[$cert_iter*4+1] = $1);
  572.  
  573.         ($state == 1) and /subject=\s*(.*)/    
  574.             and ($bag_attribs[$cert_iter*4+2] = $1);
  575.  
  576.         ($state == 1) and /issuer=\s*(.*)/     
  577.             and ($bag_attribs[$cert_iter*4+3] = $1);
  578.         
  579.         if(/^-----/) {
  580.             if(/BEGIN/) {
  581.                 print CERT_FILE;
  582.                 $state = 2;
  583.  
  584.                 if(/PRIVATE/) {
  585.                     $bag_attribs[$cert_iter*4] = "K";
  586.                     next;
  587.                 }
  588.                 if(/CERTIFICATE/) {
  589.                     $bag_attribs[$cert_iter*4] = "C";
  590.                     next;
  591.                 }
  592.                 die("What's this: $_");
  593.             }
  594.             if(/END/) {
  595.                 $state = 0;
  596.                 print CERT_FILE;
  597.                 close(CERT_FILE);
  598.                 $cert_iter++;
  599.             $cert_tmp_file[$cert_iter] = newfile("cert_tmp.$cert_iter","temp");
  600.             $cert_tmp_iter = $cert_tmp_file[$cert_iter];
  601.                 open(CERT_FILE, ">$cert_tmp_iter")
  602.                     or die "Couldn't open $cert_tmp_iter: $!";
  603.                 next;
  604.             }
  605.         }
  606.         print CERT_FILE;
  607.     }
  608.     close(CERT_FILE);
  609.  
  610.     # I'll add support for unbagged cetificates, in case this is needed.
  611.     $numBags == $cert_iter or 
  612.         die("Not all contents were bagged. can't continue.");
  613.  
  614.     return @bag_attribs;
  615. }
  616.  
  617.  
  618. # This requires the Bag Attributes to be set
  619. sub handle_pem (@) {
  620.  
  621.     my @pem_contents;
  622.     my $iter=0;
  623.     my $root_cert;
  624.     my $key;
  625.     my $certificate;
  626.     my $intermediate;
  627.     my @mailbox;
  628.     my $mailbox;
  629.  
  630.     @pem_contents = &parse_pem(@_);
  631.  
  632.     # private key and certificate use the same 'localKeyID'
  633.     while($iter <= $#pem_contents / 4) {
  634.         if($pem_contents[$iter * 4] eq "K") {
  635.             $key = $iter;
  636.             last;
  637.         }
  638.         $iter++;
  639.     }
  640.     ($iter > $#pem_contents / 2) and die("Couldn't find private key!");
  641.  
  642.     $pem_contents[($key * 4)+1] or die("Attribute 'localKeyID' wasn't set.");
  643.  
  644.     $iter = 0;
  645.     while($iter <= $#pem_contents / 4) {
  646.         $iter == $key and ($iter++) and next;
  647.         if($pem_contents[($iter * 4)+1] eq $pem_contents[($key * 4)+1]) {
  648.             $certificate = $iter;
  649.             last;
  650.         }
  651.         $iter++;
  652.     }
  653.     ($iter > $#pem_contents / 4) and die("Couldn't find matching certificate!");
  654.  
  655.     my $tmp_key = newfile("tmp_key","temp");
  656.     mycopy $cert_tmp_file[$key], $tmp_key;
  657.     my $tmp_certificate = newfile("tmp_certificate","temp");
  658.     mycopy $cert_tmp_file[$certificate], $tmp_certificate;
  659.  
  660.     # root certificate is self signed
  661.     $iter = 0;
  662.  
  663.     while($iter <= $#pem_contents / 4) {
  664.         if ($iter == $key or $iter == $certificate) {
  665.             $iter++; 
  666.             next;
  667.         }
  668.  
  669.         if($pem_contents[($iter * 4)+2] eq $pem_contents[($iter * 4)+3]) {
  670.             $root_cert = $iter;
  671.             last;
  672.         }
  673.         $iter++;
  674.     }
  675.     if ($iter > $#pem_contents / 4) {
  676.       print "Couldn't identify root certificate!\n";
  677.       $root_cert = -1;      
  678.     }
  679.  
  680.     # what's left are intermediate certificates.
  681.     $iter = 0;
  682.  
  683.     # needs to be set, so we can check it later
  684.     $intermediate = $root_cert;
  685.     my $tmp_issuer_cert = newfile("tmp_issuer_cert","temp");
  686.     while($iter <= $#pem_contents / 4) {
  687.         if ($iter == $key or $iter == $certificate or $iter == $root_cert) {
  688.             $iter++; 
  689.             next;
  690.         }
  691.  
  692.     open (IC, ">> $tmp_issuer_cert") or die "can't open $tmp_issuer_cert: $?";
  693.     my $cert_tmp_iter = $cert_tmp_file[$iter];
  694.     open (CERT, "< $cert_tmp_iter") or die "can't open $cert_tmp_iter: $?";
  695.     print IC while (<CERT>);
  696.     close IC;
  697.     close CERT;
  698.  
  699.     # although there may be many, just need to know if there was any
  700.     $intermediate = $iter;
  701.  
  702.         $iter++;
  703.     }
  704.  
  705.     # no intermediate certificates ? use root-cert instead (if that was found...)
  706.     if($intermediate == $root_cert) {
  707.         if ($root_cert == -1) {
  708.       die("No root and no intermediate certificates. Can't continue.");
  709.     }
  710.         mycopy $cert_tmp_file[$root_cert], $tmp_issuer_cert;
  711.     }
  712.  
  713.     my $label = query_label;
  714.  
  715.     my $format = -B $tmp_certificate ? 'DER' : 'PEM'; 
  716.     my $cmd = "$opensslbin x509 -noout -hash -in $tmp_certificate -inform $format";
  717.     my $cert_hash = `$cmd`;
  718.     $? and die "'$cmd' returned $?";
  719.  
  720.     $format = -B $tmp_issuer_cert ? 'DER' : 'PEM'; 
  721.     $cmd = "$opensslbin x509 -noout -hash -in $tmp_issuer_cert -inform $format";
  722.     my $issuer_hash = `$cmd`;
  723.     $? and die "'$cmd' returned $?";
  724.  
  725.     chomp($cert_hash); chomp($issuer_hash);
  726.  
  727.     # Note: $cert_hash will be changed to reflect the correct filename
  728.     #       within add_cert() ONLY, so these _have_ to get called first..
  729.     add_certificate($tmp_issuer_cert, \$issuer_hash, 0, $label);
  730.     @mailbox = &add_certificate("$tmp_certificate", \$cert_hash, 1, $label, $issuer_hash); 
  731.     foreach $mailbox (@mailbox) {
  732.       chomp($mailbox);
  733.       add_key($tmp_key, $cert_hash, $mailbox, $label);
  734.     }
  735. }
  736.  
  737.  
  738.  
  739.  
  740.  
  741.  
  742. sub modify_entry ($$$;$ ) {
  743.     my $op = shift or die;
  744.     my $hashvalue = shift or die;
  745.     my $use_cert = shift;
  746.     my $crl;
  747.     my $label;
  748.     my $path;
  749.     my @fields;
  750.  
  751.     $op eq 'L' and ($label = shift or die);
  752.     $op eq 'V' and ($crl = shift);
  753.  
  754.  
  755.     if ($use_cert) {
  756.         $path = $certificates_path;
  757.     }
  758.     else {
  759.         $path = $private_keys_path;
  760.     }
  761.  
  762.     open(INDEX, "<$path/.index") or  
  763.       die "Couldn't open $path/.index: $!";
  764.     my $newindex = newfile("$path/.index.tmp");
  765.     open(NEW_INDEX, ">$newindex") or 
  766.       die "Couldn't create $newindex: $!";
  767.  
  768.     while(<INDEX>) {
  769.         @fields = split;
  770.         if($fields[1] eq $hashvalue or $hashvalue eq 'all') {
  771.       $op eq 'R' and next;
  772.       print NEW_INDEX "$fields[0] $fields[1]";
  773.       if($op eq 'L') {
  774.         if($use_cert) {
  775.           print NEW_INDEX " $label $fields[3] $fields[4]";
  776.         }
  777.         else {
  778.           print NEW_INDEX " $label";
  779.         }
  780.       }
  781.       if ($op eq 'V') {
  782.         print "\n==> about to verify certificate of $fields[0]\n";
  783.         my $flag = &do_verify($fields[1], $fields[3], $crl);
  784.         print NEW_INDEX " $fields[2] $fields[3] $flag";
  785.       }
  786.       print NEW_INDEX "\n";
  787.       next;
  788.     }
  789.     print NEW_INDEX;
  790.     }
  791.     close(INDEX);
  792.     close(NEW_INDEX);
  793.  
  794.     rename $newindex, "$path/.index" 
  795.         or die "Couldn't rename $newindex to $path/.index: $!\n";
  796.  
  797.     print "\n";
  798. }
  799.  
  800.  
  801.  
  802.  
  803. sub remove_pair ($ ) {
  804.   my $keyid = shift or die;
  805.  
  806.   if (-e "$certificates_path/$keyid") {
  807.     unlink "$certificates_path/$keyid";
  808.     modify_entry('R', $keyid, 1);
  809.     print "Removed certificate $keyid.\n";
  810.   }
  811.   else {
  812.     die "No such certificate: $keyid";
  813.   }
  814.  
  815.   if (-e "$private_keys_path/$keyid") {
  816.     unlink "$private_keys_path/$keyid";
  817.     modify_entry('R', $keyid, 0);
  818.     print "Removed private key $keyid.\n";
  819.   }
  820. }
  821.  
  822.  
  823.  
  824. sub change_label ($ ) {
  825.   my $keyid = shift or die;
  826.   
  827.   my $label = query_label;
  828.  
  829.   if (-e "$certificates_path/$keyid") {
  830.     modify_entry('L', $keyid, 1, $label);
  831.     print "Changed label for certificate $keyid.\n";
  832.   }
  833.   else {
  834.     die "No such certificate: $keyid";
  835.   }
  836.  
  837.   if (-e "$private_keys_path/$keyid") {
  838.     modify_entry('L', $keyid, 0, $label);
  839.     print "Changed label for private key $keyid.\n";
  840.   }
  841.  
  842. }
  843.  
  844.  
  845.  
  846.  
  847. sub verify_cert ($$) {
  848.   my $keyid = shift or die;
  849.   my $crl = shift;
  850.  
  851.   -e "$certificates_path/$keyid" or $keyid eq 'all'
  852.     or die "No such certificate: $keyid";
  853.   modify_entry('V', $keyid, 1, $crl);
  854. }
  855.  
  856.  
  857.  
  858.  
  859. sub do_verify($$$) {
  860.  
  861.   my $cert = shift or die;
  862.   my $issuerid = shift or die;
  863.   my $crl = shift;
  864.  
  865.   my $result = 'i';
  866.   my $trust_q;
  867.   my $issuer_path;
  868.   my $cert_path = "$certificates_path/$cert";
  869.  
  870.   if($issuerid eq '?') {
  871.     $issuer_path = "$certificates_path/$cert";
  872.   } else {
  873.     $issuer_path = "$certificates_path/$issuerid";
  874.   }
  875.  
  876.   my $cmd = "$opensslbin verify $root_certs_switch $root_certs_path -purpose smimesign -purpose smimeencrypt -untrusted $issuer_path $cert_path";
  877.   my $output = `$cmd`;
  878.   $? and die "'$cmd' returned $?";
  879.   chop $output;
  880.   print "\n$output\n";
  881.  
  882.   ($output =~ /OK/) and ($result = 'v');
  883.  
  884.   $result eq 'i' and return $result;
  885.  
  886.   my $format = -B $cert_path ? 'DER' : 'PEM'; 
  887.   $cmd = "$opensslbin x509 -dates -serial -noout -in $cert_path -inform $format";
  888.   (my $date1_in, my $date2_in, my $serial_in) = `$cmd`;
  889.   $? and die "'$cmd' returned $?";
  890.  
  891.   if ( defined $date1_in and defined $date2_in ) {
  892.     my @tmp = split (/\=/, $date1_in);
  893.     my $tmp = $tmp[1];
  894.     @tmp = split (/\=/, $date2_in);
  895.     my %months = ('Jan', '00', 'Feb', '01', 'Mar', '02', 'Apr', '03',
  896.           'May', '04', 'Jun', '05', 'Jul', '06', 'Aug', '07',
  897.           'Sep', '08', 'Oct', '09', 'Nov', '10', 'Dec', '11');
  898.  
  899.     my @fields =
  900.       $tmp =~ /(\w+)\s*(\d+)\s*(\d+):(\d+):(\d+)\s*(\d+)\s*GMT/;
  901.  
  902.     $#fields != 5 and print "Expiration Date: Parse Error :  $tmp\n\n" or
  903.       timegm($fields[4], $fields[3], $fields[2], $fields[1],
  904.          $months{$fields[0]}, $fields[5]) > time and $result = 'e';
  905.     $result eq 'e' and print "Certificate is not yet valid.\n" and return $result;
  906.  
  907.     @fields =
  908.       $tmp[1] =~ /(\w+)\s*(\d+)\s*(\d+):(\d+):(\d+)\s*(\d+)\s*GMT/;
  909.  
  910.     $#fields != 5 and print "Expiration Date: Parse Error :  $tmp[1]\n\n" or
  911.       timegm($fields[4], $fields[3], $fields[2], $fields[1],
  912.          $months{$fields[0]}, $fields[5]) < time and $result = 'e';
  913.     $result eq 'e' and print "Certificate has expired.\n" and return $result;
  914.  
  915.   }
  916.     
  917.   if ( defined $crl ) {
  918.     my @serial = split (/\=/, $serial_in);
  919.     my $cmd = "$opensslbin crl -text -noout -in $crl | grep -A1 $serial[1]";
  920.     (my $l1, my $l2) = `$cmd`;
  921.     $? and die "'$cmd' returned $?";
  922.     
  923.     if ( defined $l2 ) {
  924.       my @revoke_date = split (/:\s/, $l2);
  925.       print "FAILURE: Certificate $cert has been revoked on $revoke_date[1]\n";
  926.       $result = 'r';
  927.     }
  928.   }    
  929.   print "\n";
  930.  
  931.   if ($result eq 'v') {
  932.     return 't';
  933.   }
  934.  
  935.   return $result;
  936. }
  937.  
  938.  
  939.  
  940. sub add_root_cert ($) {
  941.   my $root_cert = shift or die;
  942.  
  943.   my $format = -B $root_cert ? 'DER' : 'PEM'; 
  944.  
  945.   my $cmd = "$opensslbin x509 -noout -hash -in $root_cert -inform $format";
  946.   my $root_hash = `$cmd`;
  947.   $? and die "'$cmd' returned $?";
  948.  
  949.   if (-d $root_certs_path) {
  950.     -e "$root_certs_path/$root_hash" or
  951.         mycopy $root_cert, "$root_certs_path/$root_hash";
  952.   }
  953.   else {
  954.     open(ROOT_CERTS, ">>$root_certs_path") or 
  955.       die ("Couldn't open $root_certs_path for writing");
  956.  
  957.     $cmd = "$opensslbin x509 -in $root_cert -inform $format -fingerprint -noout";
  958.     $? and die "'$cmd' returned $?";
  959.     chomp(my $md5fp = `$cmd`);
  960.  
  961.     $cmd = "$opensslbin x509 -in $root_cert -inform $format -text -noout";
  962.     $? and die "'$cmd' returned $?";
  963.     my @cert_text = `$cmd`;
  964.  
  965.     print "Enter a label, name or description for this certificate: ";
  966.     my $input = <STDIN>;
  967.  
  968.     my $line = "=======================================\n";
  969.     print ROOT_CERTS "\n$input$line$md5fp\nPEM-Data:\n";
  970.  
  971.     $cmd = "$opensslbin x509 -in $root_cert -inform $format";
  972.     my $cert = `$cmd`;
  973.     $? and die "'$cmd' returned $?";
  974.     print ROOT_CERTS $cert;
  975.     print ROOT_CERTS @cert_text;
  976.     close (ROOT_CERTS);
  977.   }
  978.   
  979. }
  980.  
  981. sub newfile ($;$$) {
  982.     # returns a file name which does not exist for tmp file creation
  983.     my $filename = shift;
  984.     my $option = shift;
  985.     $option = "notemp" if (not defined($option));
  986.     if (! $tmpdir and $option eq "temp") {
  987.         $tmpdir = mutt_Q 'tmpdir';
  988.                 $tmpdir = '/tmp' if ($tmpdir =~ m/=/); # if the tmpdir contains '=', use the default
  989.         $tmpdir = newfile("$tmpdir/smime");
  990.         mkdir $tmpdir, 0700 || die "Can't create $tmpdir: $!\n";
  991.     }
  992.     $filename = "$tmpdir/$filename" if ($option eq "temp");
  993.     my $newfilename = $filename;
  994.     my $count = 0;
  995.     while (-e $newfilename) {
  996.         $newfilename = "$filename.$count";
  997.         $count++;
  998.     }
  999.     unshift(@tempfiles,$newfilename);
  1000.     return $newfilename;
  1001. }
  1002.  
  1003.  
  1004. END {
  1005.     # remove all our temporary files in the end:
  1006.     for (@tempfiles){
  1007.         if (-f) {
  1008.             unlink;
  1009.         } elsif (-d) { 
  1010.             rmdir;
  1011.         }
  1012.     }
  1013. }
  1014.